Some computer software employs user interface controls to allow the user to provide input and/or identify status. User interface controls can include text boxes to allow the user to enter text, list boxes to allow a user to select an item from a list of items or a tree-structure, such as a list of files stored in a directory, check boxes to change or display status, radio buttons to allow a mutually exclusive selection to be made from a list of items and other similar controls. Other user interface controls include scrollbars, used to indicate and control the relative position of information displayed when more information exists than is displayed on the screen at one time, and message boxes which display an informational message (e.g. “A file with that name already exists. Do you want to replace the existing file?”) and may display buttons to receive input from the user (e.g. “Yes”, “No” and “Cancel”).
Using conventional user interface controls can be cumbersome for the user. For example, once a user has selected a text box, the user may type text into the box using a cursor that is displayed as a small line inside the text box that has been most recently selected. If the user is temporarily distracted, when the user returns his or her attention to the user interface, it can be difficult to identify which control is currently selected by searching for the text box control that has the small cursor displayed. Some users use a tab selection capability for user interface controls that allows the user to use the tab key and shift-tab key to select a user interface control. Here too, conventional user interface controls do not allow the user to identify the currently selected user interface control without searching through various user interface controls located on the page to identify which user interface control is currently selected. Even if the user interface control is nearby a previously-selected user interface control, if the user is distracted, it can be difficult to locate the currently-selected user interface control.
Once the user has employed the user interface control to enter text or make a selection, an error may be detected by the application program logic that processes the information. For example, if the user is requested to enter his or her phone number in “NNN-NNN-NNNN” format, and the user enters 555-0100, the user has made an error by forgetting the area code. Conventional software may display a message box or text on the display to identify the error, but the user is still required to locate the user interface control on the page that contains the error in order to make the correction. This can require the user to search through many user interface controls and other information that may be displayed on the display screen, a cumbersome task.
User interface controls can be easier to use if the user receives feedback for the actions the user performs. For example, it can be easier to identify which control the mouse is currently over if the control provides some form of visual feedback of that event. It can also be helpful to allow the user to see that the control is being actuated, for example, changing the color of a button when it is being pressed. Some user interface controls do not provide any such feedback, making it harder for the user to use the user interface controls provided because the user has to continually search for the mouse cursor on the screen.
There is a tension between providing the space needed to allow a user interface control to indicate feedback and the desire to fit as much information onto the screen as compactly as possible without making the screen appear cluttered. For example, the conventional Motif operating system specified that user interface controls could employ a thick border around the control to indicate the currently-selected control. However, because the border is so thick, sufficient space must be left between controls not only to allow the border to be displayed, but also to allow the page on which the controls, one of which contains the border, to not appear too cluttered. Some systems such as Windows draw a faint, dotted border around certain currently-selected controls, but the border is too faint to allow the user to quickly receive the indication of feedback.
Other approaches include tooltips, whereby small, explanatory boxes pop up to provide feedback, but this takes up valuable screen space, if only temporarily, and therefore, have not solved the problem of providing feedback without taking up significant screen real estate because during the time the tooltip is displayed, it can block other portions of the screen that display information the user may wish to view.
Some user interface controls, such as certain controls provided on the RealOne Player product commercially available at the web site of real.com provide such feedback on buttons only, by means of an icon located inside the button that changes color upon mouse-over of buttons, and a bezel (a band surrounding the button) that indicates when the button is pressed by changing color. However, such feedback is too limited to be of general use on a page with other controls because the other controls provide no similar feedback. For example, the other RealOne player user interface controls such as text boxes do not provide any indication of a mouse over event. Because of this lack of consistency, the user does not develop an intuitive feel for the page containing the controls to allow the user to rely on even the rudimentary status information provided by the buttons that provide such status.
Furthermore, the RealOne approach is not particularly effective. The bezel is too small to allow the status to be easily seen, yet the bezel, and the icon, makes the buttons much larger that they would need to be without them, taking up valuable screen space, yet serving no function when the screen space they take up isn't being used to display status. Thus, using the approach of the Real Player, fewer controls can appear on the screen without making the screen appear to be overly crowded.
What is needed is a system and method that can provide a variety of easily-seen feedback for user actions related to user interface controls, yet allows the user interface controls to remain compact.